home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 007 / c.lqr / FABS.C < prev    next >
Text File  |  1985-06-03  |  16KB  |  625 lines
  1.  
  2. #define FABS_INIT "12345678901234567890123456789012345678901234567890"
  3.  
  4. /*            F A B S    K E Y   L E N G T H
  5.               ==============================
  6.  
  7.     Format is M\<file #>
  8.  
  9.     This function will get the length of the FABS key.
  10.     The following parameters are required :
  11.  
  12.     1. The file number > 0 and < 7.
  13.  
  14.     The program aborts if a FABS error occures.
  15.  
  16. */
  17. fabs_key_len( file_num )
  18. unsigned file_num ;
  19. { int adr, err ;
  20.   char *cmd ;
  21.  
  22.   cmd = FABS_INIT ;
  23.   adr = 0 ;
  24.   adr = fill_fabs( cmd, "M", adr, 0 ) ;
  25.   adr = add_num( file_num, adr, cmd, 1 ) ;
  26.  
  27. /*  printf("FABS key len string is %s\n", cmd ) ;   */
  28.  
  29.   if ( err = call_fabs( cmd ) )
  30.     return( fabs_error( "Length", cmd, err ) ) ;
  31.  
  32.   return( err ) ;
  33.  
  34. }  /* end of fabs_key_len */
  35.  
  36. call_fabs( command )
  37. char *command ;
  38. { int rec_num, key_adr, err=0 ;
  39.   extern int rec_fabs, key_fabs, err_fabs ;
  40.   char *cmnd ;
  41.  
  42.   cmnd = "????" ;    /* initialize command pointer */
  43.   rec_num = 0 ;      /* initialize record and address */
  44.   key_adr = 0 ;
  45. /*  printf("FABS string is %s\n",command ) ; */
  46.   callfb( command, strlen( command ), cmnd, &err, &rec_num, &key_adr ) ;
  47.   rec_fabs = rec_num ;
  48.   key_fabs = key_adr ;
  49.   return( err_fabs = err ) ;
  50. }
  51.  
  52. /*    Check error code for not found. If not found return with a
  53.       1 to indicate not found error. Otherwise print message and
  54.       end program.
  55. */
  56. fabs_error( txt, cmd, err )
  57. char *txt, *cmd ;
  58. int err ;
  59. {
  60.    if ( ( err > 11 ) & ( err < 17 ) )
  61.      return ;
  62.  
  63.    switch ( err )
  64.      { case 23 :
  65.        case 24 :
  66.        case 25 :
  67.        case 27 : printf( "\n\t\tFABS %s:Disk error is %d\n", txt, err );
  68.                  printf( "\t\tFABS String was %s\n", cmd ) ;
  69.                  cputs( "\t\tPress any key to continue: " ) ;
  70.                  if ( !getch() ) getch() ;       /* get any key */
  71.                  return ;
  72.      }
  73.  
  74.    printf( "\n\t\tFABS %s:Fatal error is %d\n", txt, err ) ;
  75.    printf( "\t\tFABS String was %s\n", cmd ) ;
  76.    exit( 1 ) ;
  77. }
  78.  
  79.  
  80. add_num( num, adr, cmd, last )
  81. unsigned num  ;
  82. int      adr  ;
  83. char    *cmd  ;
  84. int      last ;
  85. { char wrk_stg[ 5 ] ;
  86.  
  87.   stcu_d( wrk_stg, num, sizeof( wrk_stg) ) ;
  88.   return( fill_fabs( cmd, wrk_stg, adr, last ) ) ;
  89. }
  90.  
  91. fill_fabs( to, from, start, end )
  92. char *to, *from ;
  93. int  start,end ;
  94. { int k = 0 ;
  95.   while ( to[ start++ ] = from [ k++ ] ) ;
  96.  
  97.   if ( end )
  98.     to[ start-1 ] = '\0' ;     /* EOS */
  99.   else
  100.     to[ start-1 ] = '\\' ;     /* '\' */
  101.  
  102.   return( start ) ;
  103. }    /* end of fill_fabs */
  104.  
  105. fabs_get_key( file_num, key )
  106. unsigned file_num ;
  107. char *key ;
  108. { int key_adr ;
  109.   extern int key_fabs ;
  110.  
  111.   key_adr = key_fabs ;            /* save key address */
  112.   fabs_key_len( file_num ) ;      /* get key length */
  113. /*  printf("Key address is %d\n", key_adr );
  114.     printf("Key length is %d\n", rec_fabs );
  115. */
  116.   callky( key, rec_fabs, key_adr ) ;
  117.  
  118. }
  119. /*              F A B S    C R E A T E
  120.                 ======================
  121.  
  122.     Format is C\<file name>\<max key len>\<#keys>\<key type>\<file#>
  123.  
  124.     This function will create a file under fabs. The following
  125.     parameters are required :
  126.  
  127.     1. The file name as [d:]<filename>[.ext].
  128.     2. The key length > 0 and < 101.
  129.     3. The number of primary keys for this file.
  130.     4. The key type ( I for integer or A for ASCII ).
  131.     5. The file number > 0 and < 7.
  132.  
  133.     The program aborts if a FABS error occures.
  134.  
  135. */
  136. fabs_create( fname, key_length, num_keys, key_type, file_num )
  137. char fname[];
  138. unsigned key_length ;
  139. unsigned num_keys ;
  140. char key_type ;
  141. unsigned file_num ;
  142. { int err, adr ;
  143.   char wrk_stg[ 5 ] ;
  144.   char cmnd[ 4 ] ;
  145.   char *cmd ;
  146.  
  147.   cmd = FABS_INIT ;
  148.   adr = 0 ;
  149.   adr = fill_fabs( cmd, "C", adr, 0 ) ;
  150.   adr = fill_fabs( cmd, fname, adr, 0 ) ;
  151.   adr = add_num( key_length, adr, cmd, 0 ) ;
  152.   adr = add_num( num_keys, adr, cmd, 0 ) ;
  153.   wrk_stg[ 0 ] = key_type ;
  154.   wrk_stg[ 1 ] = '\0' ;
  155.   adr = fill_fabs( cmd, wrk_stg,adr,0) ;
  156.   adr = add_num( file_num, adr, cmd, 1 ) ;
  157.  
  158. /* printf("FABS create string is %s\n", cmd ) ; */
  159.  
  160.    if ( err = call_fabs( cmd ) )
  161.     return( fabs_error( "Create", cmd, err ) ) ;
  162.  
  163.   return( err ) ;
  164.  
  165. }  /* end of fabs_create */
  166. /*              F A B S    O P E N
  167.                 ==================
  168.  
  169.     Format is O\<file name>\<file #>
  170.  
  171.     This function will open a FABS file. The following
  172.     parameters are required :
  173.  
  174.     1. The file name as [d:]<filename>[.ext].
  175.     2. The file number > 0 and < 7.
  176.  
  177.     The program aborts if a FABS error occures.
  178.  
  179. */
  180. fabs_open( fname, file_num )
  181. char fname[];
  182. unsigned file_num ;
  183. { int adr, err ;
  184.   char *cmd ;
  185.  
  186.   cmd = FABS_INIT ;
  187.   adr = 0 ;
  188.   adr = fill_fabs( cmd, "O", adr, 0 ) ;
  189.   adr = fill_fabs( cmd, fname, adr, 0 ) ;
  190.   adr = add_num( file_num, adr, cmd, 1 ) ;
  191.  
  192. /* printf("FABS open string is %s\n",*cmd ) ;  */
  193.  
  194.   if ( err = call_fabs( cmd ) )
  195.     return( fabs_error( "Open", cmd, err ) ) ;
  196.  
  197.   return( err ) ;
  198.  
  199. }  /* end of fabs_open */
  200. /*                 F A B S    C L O S E
  201.                    ====================
  202.  
  203.     Format is K\<file #>
  204.  
  205.     This function will close an open FABS file. The following
  206.     parameters are required :
  207.  
  208.     1. The file number > 0 and < 7.
  209.  
  210.     The program aborts if a FABS error occures.
  211.  
  212. */
  213. fabs_close( file_num )
  214. unsigned file_num ;
  215. { int adr, err ;
  216.   char *cmd ;
  217.  
  218.   cmd = FABS_INIT ;
  219.   adr = 0 ;
  220.   adr = fill_fabs( cmd, "K", adr, 0 ) ;
  221.   adr = add_num( file_num, adr, cmd, 1 ) ;
  222.  
  223. /*  printf("FABS close string is %s\n", cmd ) ;  */
  224.  
  225.   if ( err = call_fabs( cmd ) )
  226.     return( fabs_error( "Close", cmd, err ) ) ;
  227.  
  228.   return( err ) ;
  229.  
  230. }  /* end of fabs_close */
  231. /*                  F A B S    I N S E R T
  232.                     ======================
  233.  
  234.     Format is I\<file number>\<key1>\..\<keyn>
  235.  
  236.     This function will insert a record into a FABS file. The following
  237.     parameters are required :
  238.  
  239.     1. The file number > 0 and < 7.
  240.     2. The keys seperated by '\'.
  241.  
  242.     The program aborts if a FABS error occures.
  243.  
  244. */
  245. fabs_insert( keys, file_num )
  246. unsigned file_num ;
  247. char keys[];
  248. { int adr, err ;
  249.   char *cmd ;
  250.  
  251.   cmd = FABS_INIT ;
  252.   adr = 0 ;
  253.   adr = fill_fabs( cmd, "I", adr, 0 ) ;
  254.   adr = add_num( file_num, adr, cmd, 0 ) ;
  255.   adr = fill_fabs( cmd, keys, adr, 1 ) ;
  256.  
  257. /* printf("FABS insert string is %s\n",cmd ) ;  */
  258.  
  259.   if ( err = call_fabs( cmd ) )
  260.     return ( fabs_error( "Insert", cmd, err ) ) ;
  261.  
  262.   return( err ) ;
  263.  
  264. }  /* end of fabs_insert */
  265. /*              F A B S    F I R S T
  266.                 ====================
  267.  
  268.     Format is F\<key #>\<file #>
  269.  
  270.     This function will find the first record in a FABS file.
  271.     The following parameters are required :
  272.  
  273.     1. The file number > 0 and < 7.
  274.     2. The key number.
  275.  
  276.     The program aborts if a FABS error occures.
  277.  
  278. */
  279. fabs_first( file_num, key_num )
  280. unsigned file_num, key_num ;
  281. { int adr, err ;
  282.   char *cmd ;
  283.  
  284.   cmd = FABS_INIT ;
  285.   adr = 0 ;
  286.   adr = fill_fabs( cmd, "F", adr, 0 ) ;
  287.   adr = add_num( key_num, adr, cmd, 0 ) ;
  288.   adr = add_num( file_num, adr, cmd, 1 ) ;
  289.  
  290. /*  printf("FABS first string is %s\n", cmd ) ;   */
  291.  
  292.   if ( err = call_fabs( cmd ) )
  293.     return( fabs_error( "First", cmd, err ) ) ;
  294.  
  295.   return( err ) ;
  296.  
  297. }  /* end of fabs_first */
  298. /*              F A B S    L A S T
  299.                 ==================
  300.  
  301.     Format is L\<key #>\<file #>
  302.  
  303.     This function will find the last record in a FABS file.
  304.     The following parameters are required :
  305.  
  306.     1. The file number > 0 and < 7.
  307.     2. The key number.
  308.  
  309.     The program aborts if a FABS error occures.
  310.  
  311. */
  312. fabs_last( file_num, key_num )
  313. unsigned file_num, key_num ;
  314. { int adr, err ;
  315.   char *cmd ;
  316.  
  317.   cmd = FABS_INIT ;
  318.   adr = 0 ;
  319.   adr = fill_fabs( cmd, "L", adr, 0 ) ;
  320.   adr = add_num( key_num, adr, cmd, 0 ) ;
  321.   adr = add_num( file_num, adr, cmd, 1 ) ;
  322.  
  323. /* printf("FABS last string is %s\n", cmd ) ; */
  324.  
  325.   if ( err = call_fabs( cmd ) )
  326.     return( fabs_error( "Last", cmd, err ) ) ;
  327.  
  328.   return( err ) ;
  329.  
  330. }  /* end of fabs_last */
  331. /*                 F A B S    N E X T
  332.                    ==================
  333.  
  334.     Format is N\<file #>
  335.  
  336.     This function will find the next key in a FABS file. The following
  337.     parameters are required :
  338.  
  339.     1. The file number > 0 and < 7.
  340.  
  341.     The program aborts if a FABS error occures.
  342.  
  343. */
  344. fabs_next( file_num )
  345. unsigned file_num ;
  346. { int adr, err ;
  347.   char *cmd ;
  348.  
  349.   cmd = FABS_INIT ;
  350.   adr = 0 ;
  351.   adr = fill_fabs( cmd, "N", adr, 0 ) ;
  352.   adr = add_num( file_num, adr, cmd, 1 ) ;
  353.  
  354. /*  printf("FABS next string is %s\n", cmd ) ;  */
  355.  
  356.   if ( err = call_fabs( cmd ) )
  357.     return( fabs_error( "Next", cmd, err ) ) ;
  358.  
  359.   return( err ) ;
  360.  
  361. }  /* end of fabs_next */
  362. /*                 F A B S    P R E V I O U S
  363.                    ==========================
  364.  
  365.     Format is P\<file #>
  366.  
  367.     This function will find the previous key in a FABS file.
  368.     The following parameters are required :
  369.  
  370.     1. The file number > 0 and < 7.
  371.  
  372.     The program aborts if a FABS error occures.
  373.  
  374. */
  375. fabs_previous( file_num )
  376. unsigned file_num ;
  377. { int adr, err ;
  378.   char *cmd ;
  379.  
  380.   cmd = FABS_INIT ;
  381.   adr = 0 ;
  382.   adr = fill_fabs( cmd, "P", adr, 0 ) ;
  383.   adr = add_num( file_num, adr, cmd, 1 ) ;
  384.  
  385. /* printf("FABS previous string is %s\n", cmd ) ;   */
  386.  
  387.   if ( err = call_fabs( cmd ) )
  388.     return( fabs_error( "Previous", cmd, err ) ) ;
  389.  
  390.   return( err ) ;
  391.  
  392. }  /* end of fabs_previous */
  393. /*                 F A B S    S E A R C H
  394.                    ======================
  395.  
  396.     Format is G\<key #>\<file #>\<key>
  397.  
  398.     This function will search a FABS file for a key. The following
  399.     parameters are required :
  400.  
  401.     1. The key number .
  402.     2. The file number > 0 and < 7.
  403.     3. The value of the key.
  404.  
  405.     The program aborts if a FABS error occures.
  406.  
  407. */
  408. fabs_search( key_num, file_num, key )
  409. unsigned key_num, file_num ;
  410. char *key ;
  411. { int adr, err ;
  412.   char *cmd ;
  413.  
  414.   cmd = FABS_INIT ;
  415.   adr = 0 ;
  416.   adr = fill_fabs( cmd, "S", adr, 0 ) ;
  417.   adr = add_num( key_num, adr, cmd, 0 ) ;
  418.   adr = add_num( file_num, adr, cmd, 0 ) ;
  419.   adr = fill_fabs( cmd, key, adr, 1 ) ;
  420.  
  421. /* printf("FABS search string is %s\n",cmd ) ;  */
  422.  
  423.   if ( err = call_fabs( cmd ) )
  424.     return( fabs_error( "Specific", cmd, err ) ) ;
  425.  
  426.   return( err ) ;
  427.  
  428. }  /* end of fabs_search */
  429. /*            F A B S    G E N E R I C    S E A R C H
  430.               =======================================
  431.  
  432.     Format is G\<key #>\<file #>\<key>
  433.  
  434.     This function will search a FABS file for the first record equal to
  435.     greater than key. The following parameters are required :
  436.  
  437.     1. The key number .
  438.     2. The file number > 0 and < 7.
  439.     3. The value of the key.
  440.  
  441.     The program aborts if a FABS error occures.
  442.  
  443. */
  444. fabs_generic( key_num, file_num, key )
  445. unsigned key_num, file_num ;
  446. char *key ;
  447. { int adr, err ;
  448.   char *cmd ;
  449.  
  450.   cmd = FABS_INIT ;
  451.   adr = 0 ;
  452.   adr = fill_fabs( cmd, "G", adr, 0 ) ;
  453.   adr = add_num( key_num, adr, cmd, 0 ) ;
  454.   adr = add_num( file_num, adr, cmd, 0 ) ;
  455.   adr = fill_fabs( cmd, key, adr, 1 ) ;
  456.  
  457. /* printf("FABS generic string is %s\n", cmd ) ;   */
  458.  
  459.   if ( err = call_fabs( cmd ) )
  460.     return( fabs_error( "Generic", cmd, err ) ) ;
  461.  
  462.   return( err ) ;
  463.  
  464. }  /* end of fabs_generic */
  465. /*                  F A B S    B U I L D   K E Y
  466.                     ============================
  467.  
  468.     Format is B\<file number>\<key1>\..\<keyn>
  469.  
  470.     This function will insert a record into a FABS file without
  471.     updating the map file. A write map FABS call must be executed
  472.     after a series of build calls. The following parameters are
  473.     required :
  474.  
  475.     1. The file number > 0 and < 7.
  476.     2. The keys seperated by '\'.
  477.  
  478.     The program aborts if a FABS error occures.
  479.  
  480. */
  481. fabs_build( keys, file_num )
  482. unsigned file_num ;
  483. char keys[];
  484. { int adr, err ;
  485.   char *cmd ;
  486.  
  487.   cmd = FABS_INIT ;
  488.   adr = 0 ;
  489.   ad( keys, file_num )
  490. unsigned file_num ;
  491. char keys[];
  492. { int adr, err ;
  493.   char *cmd ;
  494.  
  495.   cmd = FABS_INIT ;
  496.   adr = 0 ;
  497.   adr = fill_fabs( cmd, "B", adr, 0 ) ;
  498.   adr = add_num( file_num, adr, cmd, 0 ) ;
  499.   adr = fill_fabs( cmd, keys, adr, 1 ) ;
  500.  
  501. /* printf("FABS insert string is %s\n",cmd ) ;  */
  502.  
  503.   if ( err = call_fabs( cmd ) )
  504.     return ( fabs_error( "Build", cmd, err ) ) ;
  505.  
  506.   return( err ) ;
  507.  
  508. }  /* end of fabs_build */
  509. /*                   F A B S    M A P
  510.                      ================
  511.  
  512.     Format is W\<file #>
  513.  
  514.     This function will write the map file. This function must be
  515.     executed after a series of build commands. The following
  516.     parameters are required :
  517.  
  518.     1. The file number > 0 and < 7.
  519.  
  520.     The program aborts if a FABS error occures.
  521.  
  522. */
  523. fabs_map( file_num )
  524. unsigned file_num ;
  525. { int adr, err ;
  526.   char *cmd ;
  527.  
  528.   cmd = FABS_INIT ;
  529.   adr = 0 ;
  530.   adr = fill_fabs( cmd, "W", adr, 0 ) ;
  531.   adr = add_num( file_num, adr, cmd, 1 ) ;
  532.  
  533. /*  printf("FABS write string is %s\n", cmd ) ;  */
  534.  
  535.   if ( err = call_fabs( cmd ) )
  536.     return( fabs_error( "Write", cmd, err ) ) ;
  537.  
  538.   return( err ) ;
  539.  
  540. }  /* end of fabs_map */
  541. /*                  F A B S    D E L E T E
  542.                     ======================
  543.  
  544.     Format is D\<record number>\<SBDF>\<file number>\<key1>\..\<keyn>
  545.  
  546.     This function will delete a record from a FABS file. The following
  547.     parameters are required :
  548.  
  549.     1. The file record number.
  550.     1. The search before delete flag.
  551.     1. The file number > 0 and < 7.
  552.     2. The keys seperated by '\'.
  553.  
  554.     The program aborts if a FABS error occures.
  555.  
  556. */
  557. fabs_delete( rec_num, SBDF, keys, file_num )
  558. unsigned file_num ;
  559. unsigned rec_num ;
  560. char SBDF;
  561. char keys[];
  562. { int adr, err ;
  563.   char *cmd ;
  564.  
  565.   cmd = FABS_INIT ;
  566.   adr = 0 ;
  567.   adr = fill_fabs( cmd, "D", adr, 0 ) ;
  568.   adr = add_num( rec_num, adr, cmd, 0 ) ;
  569.   if ( SBDF == 'N' )
  570.     adr = fill_fabs( cmd, "N", adr, 0 ) ;
  571.   else
  572.     adr = fill_fabs( cmd, "Y", adr, 0 ) ;
  573.   adr = add_num( file_num, adr, cmd, 0 ) ;
  574.   adr = fill_fabs( cmd, keys, adr, 1 ) ;
  575.  
  576. /* printf("FABS delete string is %s\n",cmd ) ;  */
  577.  
  578.   if ( err = call_fabs( cmd ) )
  579.     return ( fabs_error( "Delete", cmd, err ) ) ;
  580.  
  581.   return( err ) ;
  582.  
  583. }  /* end of fabs_delete */
  584. /*                  F A B S    R E P L A C E
  585.                     ========================
  586.  
  587.     Format is R\<key num>\<rec num>\<file num>\<old key>\<new key>
  588.  
  589.     This function will replace a single key with another key using the
  590.     same record number and primary key number.The following
  591.     parameters are required :
  592.  
  593.     1. The key number.
  594.     2. The record number to replace.
  595.     3. The file number > 0 and < 7.
  596.     4. The old key.
  597.     5. The new key.
  598.  
  599.     The program aborts if a FABS error occures.
  600.  
  601. */
  602. fabs_replace( key_num, rec_num,file_num, old_key, new_key )
  603. unsigned key_num, rec_num, file_num ;
  604. char old_key[], new_key[];
  605. { int adr, err ;
  606.   char *cmd ;
  607.  
  608.   cmd = FABS_INIT ;
  609.   adr = 0 ;
  610.   adr = fill_fabs( cmd, "R", adr, 0 ) ;
  611.   adr = add_num( key_num, adr, cmd, 0 ) ;
  612.   adr = add_num( rec_num, adr, cmd, 0 ) ;
  613.   adr = add_num( file_num, adr, cmd, 0 ) ;
  614.   adr = fill_fabs( cmd, old_key, adr, 0 ) ;
  615.   adr = fill_fabs( cmd, new_key, adr, 1 ) ;
  616.  
  617. /* printf("FABS replace string is %s\n",cmd ) ;  */
  618.  
  619.   if ( err = call_fabs( cmd ) )
  620.     return ( fabs_error( "Replace", cmd, err ) ) ;
  621.  
  622.   return( err ) ;
  623.  
  624. }  /* end of fabs_replace */
  625.